#include <iostream>

using namespace std;
class AAA
{
public:
    AAA() {}
public:
    int GetAAA(int x,int y = 10);
};

//int AAA::GetAAA(int x,int y =10)
// 函数实现处不加默认值
int AAA::GetAAA(int x,int y)
{
    cout << "AAA : x,y: " << x << " " << y << endl;
    return 0;
}

int main()
{
#if 0
    // constexpr 关键字,c++11引入的,常量的概念,在编译的时候求值,肯定能提高性能.
    // 1.显示类型转换,c语言强制转换(int)3.2
    // c++强制类型转换分为4中,
    // 1.static_cast
    // 2.dynamic_cast
    // 3.const_cast
    // 4.reinterpret_cast
    // 强制类型转换名<type>(express)

    // static_cast 静态转换,正常转换,编译的时候就会进行类型转换.和c语言强转类似,c风格的强制类型转换,以及编译器能够进行隐式类型转换,都可以用static_cast转换.
    double f = 100.3f;
    int i = (int)f;// c强转
    // 1.相关类型转换,比如int
    int i2 = static_cast<int>(f);
    cout << "i :" << i << " i2:" << i2 << endl;

    // 2.子类转成父类
    class A{};
    class B:public A{};

    B b;
    A a = static_cast<A> (b);
    // B c = static_cast<B> (a);

    // 3.void *与其他类型指针转换,可以指向任何指针类型的万能指针.
    int ii = 10;
    int *p = &ii;
    void *q = static_cast<void *>(p);// 把int* 转成void*
    //cout << "q:" << *q << endl;
    int *db = static_cast<int *>(q);
    cout << "db:" << *db << endl;

    // dynamic_cast 应用于运行时类型时类型识别和检查,主要用于父类型和子类型之间转换用的
    // const_cast: 去除指针或者引用的const属性,转换能够将const性质转换掉.
    //
    const int a1 = 90;
    //int a2 = const_cast<int>(a1);// a1不是指针或引用不能转
    const int *pa1 = &a1;
    int *pa2 = const_cast<int *>(pa1);
    *pa2 = 20;
    cout << "*p1 " << *pa1 << endl;
    // 4.reinterpret_cast 重新解析,乱转,自由转
    // 将一个整形(地址)转换成指针,一种类型指针转换成另一种类型指针,按照转换后的内容重新解释内存中的内容
    // 也可以从一个指针类型转换成一个整形.
    int i4 =  10;
    int *p4 = &i;
    int *p2 = reinterpret_cast<int *>(&i);
#endif
#if 1
    static int count = 1;
    class Time
    {
    public:
        int m_Hour;
        int m_min;
        int m_Sec;
    public:
        // 构造函数
        Time()
        {
            cout << "Time() " << count << endl;
        }
        Time(int i)
        {
            cout << "Time() one " << i << endl;
        }
        Time(int hour,int min, int sec)
        {
            cout << "Time() " << hour << " " << min << " " << sec << endl;
        }
    };
    // 构造函数
    // 在类中具有一种特殊的成员函数.它的名字和类名相同,我们在创建类的对象的时候,这个特殊的成员函数就会被系统自动调用.
    // 1.因为构造函数就会被系统自动调用,所以我们可以简单的理解为:构造函数的目的就是初始化对象的数据成员.
    // 1.1 构造函数没有返回值,这也是构造函数的特殊之处.
    // 1.2 不可以手工调用构造函数,否则编译就会出错.
    // 1.3 正常情况下,构造函数应该被声明为public,因为我们创建一个对象时,系统就会替我们调用构造函数,这说明构造函数它是一个public函数.
    // 因为累缺省的成员是私有成员,所以我们必须说明构造函数是一个public函数,否则就无法直接创建该类的对象.
    // 构造函数中,有多个参数,我们要传这些参数.
    Time myTime1 = Time();// 创建构造类
    count++;
    Time myTime2;
    count++;
    Time myTime92;
    count++;
    //    Time myTime33();// 不调用构造函数
    //    Time myTime34();
    //    Time myTime35();
    count++;
    Time myTime4 = Time{};
    count++;
    Time myTime5{};
    count++;
    Time myTime6 = {};

    Time myTime7 = Time(1,2,3);// 创建构造类
    Time myTime8(4,5,6);
    Time myTime9 = Time{7,8,9};
    Time myTime10{10,11,12};
    Time myTime11 = {13,14,15};
    // 对象拷贝
    //Time myTime10;
    // 在函数默认参数
    // 1.默认值只能够放在函数声明中,除非该函数没有函数声明
    // 2.具有多个参数丶函数中指定默认值,默认值出现不默认参数的右边.
    AAA aaa;
    aaa.GetAAA(10);
#endif
    cout << "Hello World!" << endl;

    // 隐式转换和explicit
    // Time myTime20 = 20;// err
    // Time myTime21 =(13,14,15,14,17);// err
    // 当定义了一个参数的构造时
    // 这种是模糊不清的写法,存在对象
     Time myTime20 = 20;// Time() one 20
     Time myTime21 =(13,14,15,14,17);// Time() one 17
     Time myTime22 = 29.22;// Time() one 29
     Time myTime23 = 'a';// Time() one 97

    return 0;
}

